Swift3 GCD

#

Swift3 的gcd变化很大，这里列举一下，大家可以有个对照：

1、Create a serial queue 创建一个serial queue

OC

1
2
3
4
5
6
dispatch_queue_t queue = dispatch_queue_create("com.leacode.gcd.serialqueue", DISPATCH_QUEUE_SERIAL); dispatch_async(queue, ^{
    // 在queue线程执行
    dispatch_async(dispatch_get_main_queue(), ^{
        // 回到主线程
    });
});

Swift3

1
2
3
4
5
6
7
8
let queue = DispatchQueue(label: "com.leacode.gcd.serialqueue")
    queue.async {
        // 在queue线程执行
        DispatchQueue.main.async {
            // 回到主线程
        }

 }

2、Create a concurrent queue 创建一个concurrent queue

OC

1
2
3
4
5
6
7
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.leacode.gcd.concurrentqueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentQueue, ^{
        // 在queue线程执行
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程
        });
    });

Swift3

1
2
3
4
5
6
7
let queue = DispatchQueue(label: "com.leacode.gcd.concurrentqueue", attributes: [.concurrent])
    queue.async {
        // 在queue线程执行
        DispatchQueue.main.async {
            // 回到主线程
        }
}

3.系统提供的Concurrent Dispatch Queue：

从ios8开始苹果引入了一个新的概念 QoS（quality of service），有了更贴近使用场景的描述以及更细致的划分，代码如下
OC

1
2
3
4
5
6
7
8
9
10
11
12
13
if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0) {
        dispatch_queue_attr_t globalDispatchQueueBackground = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_BACKGROUND, 0);
        dispatch_queue_attr_t globalDispatchQueueUtility = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_UTILITY, 0);
        dispatch_queue_attr_t globalDispatchQueueDefault = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_DEFAULT, 0);
        dispatch_queue_attr_t globalDispatchQueueUserInitiated = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_USER_INITIATED, 0);
        dispatch_queue_attr_t globalDispatchQueueUserInteractive = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_USER_INTERACTIVE, 0);
        dispatch_queue_attr_t globalDispatchQueueUnspecified = dispatch_queue_attr_make_with_qos_class(nil, QOS_CLASS_UNSPECIFIED, 0);
    } else {
        dispatch_queue_t globalDispatchQueueHigh =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
        dispatch_queue_t globalDispatchQueueDefault =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        dispatch_queue_t globalDispatchQueueLow =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
        dispatch_queue_t globalDispatchQueueBackground =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
}

Swift3

1
2
3
4
5
6
7
8
9
10
11
12
13
if #available(iOS 8.0, *) {
            let globalDispatchQueueBackground = DispatchQueue.global(qos: DispatchQoS.QoSClass.background)
            let globalDispatchQueueUtility = DispatchQueue.global(qos: DispatchQoS.QoSClass.utility)
            let globalDispatchQueueDefault = DispatchQueue.global(qos: DispatchQoS.QoSClass.default)
            let globalDispatchQueueUserInitiated = DispatchQueue.global(qos: DispatchQoS.QoSClass.userInteractive)
            let globalDispatchQueueUserInteractive = DispatchQueue.global(qos: DispatchQoS.QoSClass.userInteractive)
            let globalDispatchQueueUnspecified = DispatchQueue.global(qos: DispatchQoS.QoSClass.unspecified)
        } else {
            let globalDispatchQueueBackground = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.background)
            let globalDispatchQueueLow = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.low)
            let globalDispatchQueueDefault = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.default)
            let globalDispatchQueueHigh = DispatchQueue.global(priority: DispatchQueue.GlobalQueuePriority.high)
 }

4.dispatch_after

这部分Swift3的变化较大
OC

1
2
3
4
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC);
dispatch_after(time, dispatch_get_main_queue(), ^{
    NSLog(@"%@", @"3秒后执行");
});

Swift3

1
2
3
4
5
6
7
8
9
let time = DispatchTime.now() + 3
DispatchQueue.main.asyncAfter(deadline: time) { 
    // 3秒后执行
    print("3秒后执行")
}
 DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 6) {
       // 6秒后执行2
       print("6秒后执行")
}

5.挂起和恢复

OC

1
2
dispatch_suspend(queue);
dispatch_resume(queue);

Swift3

1
2
queue.suspend()
queue.resume()

6.判断间隔一段时间group是否执行结束

OC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
dispatch_queue_t queue1 = dispatch_queue_create("com.leacode.gcd.queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("com.leacode.gcd.queue2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("com.leacode.gcd.queue3", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue4 = dispatch_queue_create("com.leacode.gcd.queue4", DISPATCH_QUEUE_SERIAL);

dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue1, ^{

});
dispatch_group_async(group, queue2, ^{

});
dispatch_group_async(group, queue3, ^{

});
dispatch_group_async(group, queue4, ^{

});

dispatch_time_t group_time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, group_time);
if (result == 0) {
    /*
     * 属于Dispatch Group的全部处理执行结束
     */
} else {
    /*
     * 属于Dispatch Group的某一个处理还在进行中
     */
}

dispatch_group_notify(group, dispatch_get_main_queue(), ^{

});

Swift3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
let queue1 = DispatchQueue(label: "com.leacode.group.queue1")
let queue2 = DispatchQueue(label: "com.leacode.group.queue2")
let queue3 = DispatchQueue(label: "com.leacode.group.queue3")
let group = DispatchGroup()

queue1.async(group: group) {

}
queue2.async(group: group) {

}
queue3.async(group: group) {

 }

/*
* 以下代码可以判断间隔时间为1秒后group是否执行完毕，并执行相应的处理
*/
let afterTime = DispatchTime.now() + 1
let result = group.wait(timeout: afterTime)

if result == .success {
      /*
       * 属于Dispatch Group的全部处理执行结束
       */
    } else {
        /*
         * 属于Dispatch Group的某一个处理还在进行中
         */
    }

    group.notify(queue: DispatchQueue.main) {

    }

7.dispatch_once

这里我们用单例来举例，oc和swift中都是通过创建一个static对象来创建单例子，在swift3中只需要写一个static变量就可以了：
OC

1
2
3
4
5
6
7
8
9
+ (id)sharedInstance
{
    static MyClass *myclass = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        myclass = [[self alloc] init];
    });
    return myclass;
}

Swift

1
2
3
4
5
6
class MyClass {
    static let singleton = MyClass()
    private init() {
        print("foo")
    }
}

在swift中已经取消掉dispatch_once了，可以看苹果的说明链接

The free function dispatch_once
is no longer available in Swift. In Swift, you can use lazily initialized globals or static properties and get the same thread-safety and called-once guarantees as dispatch_once
provided

可以通过设置懒加载的全局属性或者静态属性来达到线程安全且执行一次的效果。

赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码
本站总访问量次 总访客数人次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家